MexicoMapsLink="https://github.com/AyeliAlp/ejercicicios_sem11/raw/main/maps/mexicoMaps_6366.gpkg"

from  fiona import listlayers


#layers in maps
listlayers(MexicoMapsLink)

#Primero descargamos informacion importante sobre los principales puertos y terminales a nivel mundial
#y los leemos
import pandas as pd 
infoseaports=pd.read_csv(os.path.join("data","UpdatedPub150.csv"))

#columns available (so many)
infoseaports.columns.to_list()

#Primero reenombramos la columna Main Port Name a portName. Luego, obtenemos la información
#general y resumida sobre el DataFrame
infoseaports.rename(columns={'Main Port Name':'portName'},inplace=True)
infoseaports=infoseaports.loc[:,['portName', 'Country Code','Latitude', 'Longitude']]
infoseaports.info()

#Creamos un nuevo DataFrame llamado largeAirports seleccionando "airports" donde el valor de la columna
#"kind" es "large_airport". Luego, graficamos los aeropuertos que se representan como triangulos rojos
#y los punto celestes representan a los puertos maritimos de mexico.
# subsetting
largeAirports=airports[airports.kind=='large_airport'] 
largeAirports.reset_index(drop=True, inplace=True)

#plotting
base=largeAirports.plot(color='red',marker="^")
seaports_mex_6366.plot(ax=base,alpha=0.5,markersize=3)

#Distance
#Between points
#The easiest way to understand distance is to compute how far two coordinates are from each other.

#Visualizamos los puertos maritimos de Mexico:

seaports_mex_6366.head()

#Visualizamos los aeropuertos grandes de Mexico:

largeAirports.head()

#Si ambos GeoDataFrame tienen en el mismo crs proyectado, podemos usar la funcion distancia:

#Calculamos la distancia en kilometros entre la geometria del primer aeropuerto grande que aparece 
#en el DataFrame y la geometria del primer puerto del DataFrame "seaports_mex_6366"
largeAirports.iloc[0].geometry.distance(seaports_mex_6366.iloc[0].geometry)/1000

#Calculamos todas las distancias entre cada geometria de los puertos y todas las geometrias de los
#aeropuertos en km:

#Prueba 1
seaports_mex_6366.geometry.apply\
(lambda g: largeAirports.geometry.distance(g)/1000)

#Aaui tambien calculamos las distancias pero esta vez utilizamos los nombres de los puertos y aeropuertos como indices
#para realizar la comparación, en km.
#Prueba 2
seaports_mex_6366.set_index('portName').geometry.apply\
(lambda g: largeAirports.set_index('name').geometry.distance(g)/1000)

#calculamos las distancias en kilómetros entre cada puerto en seaports_mex_6366 y todos los aeropuertos en largeAirports, utilizando 
#los nombres como índices para realizar la comparación. Luego, ordenamos los resultados por los nombres de los puertos y 
#los nombres de los aeropuertos, tanto en las filas como en las columnas.
#Prueba 3
seaports_mex_6366.set_index('portName').geometry.apply\
(lambda g: largeAirports.set_index('name').geometry.distance(g)/1000).\
sort_index(axis=0).sort_index(axis=1)

#Este es un marco de datos (pandas), y las instalaciones son índices de fila y columna. Esto es útil de esta manera:

#calculamos el promedio de las distancias en kilómetros entre cada puerto en seaports_mex_6366 y los aeropuertos en largeAirports, y luego mostr 
#los puertos ordenados en función de sus distancias promedio de menor a mayor
distanceMatrixKM_sea_air.mean(axis=1).sort_values(ascending=True)

#Calcuamos el promedio de las distancias para cada puerto, la distancia minima para cada puerto y 
#la distancia maxima para cada puerto:

SomeStats=pd.DataFrame()
SomeStats['mean']=distanceMatrixKM_sea_air.mean(axis=1)
SomeStats['min']=distanceMatrixKM_sea_air.min(axis=1)
SomeStats['max']=distanceMatrixKM_sea_air.max(axis=1)
SomeStats.head()

#También podemos usar idxmax para obtener las ubicaciones particulares:

#Buscamos el indice del valor maximo en cada fila de la matriz de distancia
#(aeropuerto más lejano a cada puerto marítimo) 
distanceMatrixKM_sea_air.idxmax(axis="columns")

#puerto marítimo más lejano a cada aeropuerto 
distanceMatrixKM_sea_air.idxmax(axis="rows")

#aeropuerto más cercano a cada puerto de mar
distanceMatrixKM_sea_air.idxmin(axis="columns")

#puerto marítimo más cercano a cada aeropuerto
distanceMatrixKM_sea_air.idxmin(axis="rows")

#Distancia entre línea y punto
#Visualizamos los rios que tenemos:

rivers

#Mantenemos uno:

rivers[rivers.NAME.str.contains('Grande')]

#Puedes ver que la distancia funciona entre estos dos elementos::

rivers[rivers.NAME.str.contains('Grande')].iloc[0].geometry.distance(largeAirports.geometry)

#Basándonos en lo que hicimos anteriormente, calculemos todas las distancias en kilómetros entre cada río en rivers y todos los aeropuertos en largeAirports, 
#utilizando los nombres de los ríos y los aeropuertos como índices.

distanceMatrixKM_riv_air=rivers.set_index('NAME').geometry.apply\
(lambda g: largeAirports.set_index('name').geometry.distance(g)/1000).\
sort_index(axis=0).sort_index(axis=1)
distanceMatrixKM_riv_air

#Aquí, vemos una fila (río), que indica la distancia a cada columna (aeropuerto grande):
distanceMatrixKM_riv_air.loc['Rio Grande, North America'].sort_values()

#Graficamos:

base=rivers[rivers.NAME.str.contains('Grande')].explore()
largeAirports.explore(m=base,color='red',marker_kwds=dict(radius=10))

#Nos centramos en los que pertenecen a un sistema, pero al correr el digo estos datos no presentan informacion sobre 
#quienes pertenecen a un sistema 

rivers[~rivers.SYSTEM.isna()]

#Disolvemos los que pertenecen a un sistema en una multilínea:

systems=rivers.dissolve(by='SYSTEM')
systems

#Creamos una nueva columna que contenga los nombres de los sistemas que contiene los nombres de los sistemas:

# format the GDF:
systems['NAME']=systems.index
systems.reset_index(drop=True,inplace=True)
systems

#Calculamos la matriz de distancia en kilometros entre los sistemas y los grandes aeropuertos.
#Pero como no presentamos informacion de sistema, el codigo nos arrojará un error.

distanceMatrixKM_sys_air=systems.set_index('NAME').geometry.apply\
(lambda g: largeAirports.set_index('name').geometry.distance(g)/1000).\
sort_index(axis=0).sort_index(axis=0)

distanceMatrixKM_sys_air

#Uso de búferes
#Un caso muy importante en el análisis de distancias es el uso de buffers:

#Recordamos el DataFrame que creamos hace un momento:
distanceMatrixKM_riv_air

#Obtenemos el valor de Colorado
distanceMatrixKM_riv_air.loc['Colorado'].min()

#Creamos un buffer con cualquier valor, en este caso utilizamos Colorado:

minMts=distanceMatrixKM_riv_air.loc['Colorado'].min()*1000

#El buffer es un poligono:
rivers[rivers.NAME=='Colorado'].buffer(distance = minMts)

#Visualizamos el buffer:
bufferAroundColorado=rivers[rivers.NAME=='Colorado'].buffer(distance = minMts)
bufferAsBase=bufferAroundColorado.explore(color='red')
rivers[rivers.NAME=='Colorado'].explore(m=bufferAsBase,color='blue',style_kwds={'weight':0.5})

#Al buffer le agregaremos una capa de aeropuertos pequeños:

small_airports=airports[airports.kind=='small_airport']

# plotting
rivers[rivers.NAME=='Colorado'].explore(m=bufferAsBase,color='blue',style_kwds={'weight':0.5})
small_airports.explore(m=bufferAsBase,color='black')

#Ahora, podemos usar el buffer (polígono) para mantener los aeropuertos que están a esa distancia particular alrededor del río:

riversWithinBuffer=small_airports.clip(mask=bufferAroundColorado)
#
riversWithinBuffer

#Visualizamos interactivamente al buffer alrededor del rio colorado en rojo, el rio Colorado en azul
#y los rios dentro del buffer en negro
bufferAsBase=bufferAroundColorado.explore(color='red')
rivers[rivers.NAME=='Colorado'].explore(m=bufferAsBase,color='blue',style_kwds={'weight':0.5})
riversWithinBuffer.explore(m=bufferAsBase,color='black')

#Calculamos el mínimo de todos los mínimos por fila 
distanceMatrixKM_riv_air.min(axis=1).min() 

#Usamos el valor anterior y realizamos una visualizacion intercativa que incluye un buffer alrededor de los rios en el DataFrame "rivers" 
#resaltado en rojo. Tambien se visualizarán los rios en azul y los aeropuertos en negro. 
minMinMts_5=5*distanceMatrixKM_riv_air.min(axis=1).min()*1000


allMinBuffer=rivers.buffer(distance = minMinMts_5).explore(color='red')
rivers.explore(m=allMinBuffer,color='blue',style_kwds={'weight':0.5})
small_airports.explore(m=allMinBuffer,color='black')

#Vemos todos los poligonos de buffer:
rivers.buffer(distance = minMinMts_5)

#Verificamos el tipo
riversAll_buf=rivers.buffer(distance = minMinMts_5)
type(riversAll_buf)

#Formateamos:
riversAll_bufDF=riversAll_buf.to_frame()
riversAll_bufDF.rename(columns={0:'geometry'},inplace=True)
riversAll_bufDF = riversAll_bufDF.set_geometry("geometry")
riversAll_bufDF.crs

#Hacemos un recorte entre las capas small_airports y riversAll_bufDF, y luego guarda el resultado en el DataFrame allRiversWithinBuffs
allRiversWithinBuffs=small_airports.clip(riversAll_bufDF)
allRiversWithinBuffs

#Graficamos
base=riversAll_bufDF.plot(color='yellow')
allRiversWithinBuffs.plot(ax=base, color='green', markersize=1)

#Graficamos de manera interactiva

base=riversAll_bufDF.explore(color='yellow')
allRiversWithinBuffs.explore(m=base, color='green')